/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package restaurante.cci;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import javax.swing.table.DefaultTableModel;
import javax.swing.table.TableModel;
import restaurante.cdp.*;
import restaurante.cdp.enuns.TipoProduto;
import restaurante.cgt.AplCadastroInterno;
import restaurante.cih.JanFormularioFuncionario;
import restaurante.cih.JanFormularioProduto;
import restaurante.cih.JanRelatorioFuncionario;
import restaurante.cih.JanRelatorioProduto;
import restaurante.util.Rest.tipo;

/**
 *
 * @author Gabriel
 */
public class CtrlInterno {

    private AplCadastroInterno aplControleInterno = AplCadastroInterno.getInstance();
    private static JanFormularioFuncionario janFormularioFuncionario;
    private static JanFormularioProduto janFormularioProduto;
    private static JanRelatorioFuncionario janRelatorioFuncionario;
    private static JanRelatorioProduto janRelatorioProduto;
    private static CtrlInterno instance;
   

    private CtrlInterno() {
    }


    /**
     * Obtém uma instância da aplicação. Implementação do padrão Singleton.
     */
    public static CtrlInterno getInstance() {
        if (instance == null) {
            instance = new CtrlInterno();
            try
            {
                janFormularioFuncionario = JanFormularioFuncionario.getInstance();
                janFormularioProduto = JanFormularioProduto.getInstance();
                janRelatorioFuncionario = JanRelatorioFuncionario.getInstance();
                janRelatorioProduto = JanRelatorioProduto.getInstance();
            }
            catch(Exception ex)
            {
                System.err.println(ex);
            }
        }
        return instance;
    }
    
    /**
     * Inclui uma nova telefonista
     * @param componentes
     * @return A telefonista cadastrada
     */
    public Telefonista incluirTelefonista(List componentes)
    {
        try {
            System.out.println("CtrlInterno - incluirTelefonista(List componentes)");
            return aplControleInterno.incluirTelefonista(componentes);
        } 
        catch (Exception ex) {
            System.out.println("Erro em incluir a telefonista!");
            return null;
        }
    }
    
    /**
     * Altera uma telefonista
     * @param componentes
     * @param telefonista 
     */
    public void alterarTelefonista(List componentes, Telefonista telefonista)
    {
        try {
            System.out.println("CtrlInterno -alterarTelefonista(List componentes, Telefonista telefonista)");
            aplControleInterno.alterarTelefonista(componentes, telefonista);
        } 
        catch (Exception ex) {
            System.err.println("Erro em alterar a telefonista!");
        }
    }

    /**
     * Obtem todas as telefonistas cadastradas
     * @return Uma lista com as telefonistas
     */
    public List<Telefonista> obterTelefonistas() {
        try {
            System.out.println("CtrlInterno -obterTelefonistas()");
            return aplControleInterno.obterTelefonistas();
        } catch (Exception ex) {
            System.err.println(ex.getMessage());
            System.err.println("Erro em obter as telefonistas!");
            return null;

        }
    }
    
    /**
     * Exclui uma telefonista
     * @param telefonista 
     */
    public void excluirTelefonista(Telefonista telefonista)
    {
        try {
            System.out.println("CtrlInterno -  excluirTelefonista(Telefonista telefonista)");
            aplControleInterno.apagarTelefonista(telefonista);
        } 
        catch (Exception ex) {
            System.err.println("Erro em excluir o telefonista!");
        }
    }
    
    /**
     * Inclui um motoboy
     * @param componentes
     * @return O motoboy cadastrado
     */
    public Motoboy incluirMotoboy(List componentes)
    {
        try {
            System.out.println("CtrlInterno -  incluirMotoboy(List componentes)");
            return aplControleInterno.incluirMotoboy(componentes);
        } 
        catch (Exception ex) {
            System.out.println("Erro em incluir o motoboy!");
            return null;
        }
    }
    
    /**
     * Altera um motoboy
     * @param componentes
     * @param motoboy 
     */
    public void alterarMotoboy(List componentes, Motoboy motoboy)
    {
        try {
            System.out.println("CtrlInterno - alterarMotoboy(List componentes, Motoboy motoboy)");
            aplControleInterno.alterarMotoboy(componentes, motoboy);
        } 
        catch (Exception ex) {
            System.err.println("Erro em alterar o motoboy!");
        }
    }

    /**
     * Obtem todos os motoboys cadastrados
     * @return Um lista com os motoboys
     */
    public List<Motoboy> obterMotoboys() {
        try {
            System.out.println("CtrlInterno - obterMotoboys()");
            return aplControleInterno.obterMotoboys();
        } catch (Exception ex) {
            System.err.println(ex.getMessage());
            System.err.println("Erro em obter os motoboys!");
            return null;

        }
    }
    
    /**
     * Exclui um motoboy
     * @param motoboy 
     */
    public void excluirMotoboy(Motoboy motoboy)
    {
        try {
            System.out.println("CtrlInterno - excluirMotoboy(Motoboy motoboy)");
            aplControleInterno.apagarMotoboy(motoboy);
        } 
        catch (Exception ex) {
            System.err.println("Erro em excluir o motoboy!");
        }
    }
    
    /**
     * Inclui um garçom
     * @param componentes
     * @return O garcom cadastrados
     */
    public Garcom incluirGarcom(List componentes)
    {
        try {
            System.out.println("CtrlInterno - incluirGarcom(List componentes)");
            return aplControleInterno.incluirGarcom(componentes);
        } 
        catch (Exception ex) {
            System.out.println("Erro em incluir o garcom!");
            return null;
        }
    }
    
    /**
     * Altera um garçom
     * @param componentes
     * @param garcom 
     */
    public void alterarGarcom(List componentes, Garcom garcom)
    {
        try {
            System.out.println("CtrlInterno -  alterarGarcom(List componentes, Garcom garcom)");
            aplControleInterno.alterarGarcom(componentes, garcom);
        } 
        catch (Exception ex) {
            System.err.println("Erro em alterar o garcom!");
        }
    }

    /**
     * Obtem todos os garçons cadastrados
     * @return Uma lista com os garçons
     */
    public List<Garcom> obterGarcons() {
        try {
            System.out.println("CtrlInterno - obterGarcons()");
            return aplControleInterno.obterGarcons();
        } catch (Exception ex) {
            System.err.println(ex.getMessage());
            System.err.println("Erro em obter os garcons!");
            return null;

        }
    }
    
    /**
     * Exclui um garçom
     * @param garcom 
     */
    public void excluirGarcom(Garcom garcom)
    {
        try {
            System.out.println("CtrlInterno - excluirGarcom(Garcom garcom)");
            aplControleInterno.apagarGarcom(garcom);
        } 
        catch (Exception ex) {
            System.err.println("Erro em excluir o garcom!");
        }
    }
    
    /**
     * Inclui um cozinheiro
     * @param componentes
     * @return O cozinheiro cadastrado
     */
    public Cozinheiro incluirCozinheiro(List componentes)
    {
        try {
            System.out.println("CtrlInterno -  incluirCozinheiro(List componentes)");
            return aplControleInterno.incluirCozinheiro(componentes);
        } 
        catch (Exception ex) {
            System.out.println("Erro em incluir o cozinheiro!");
            return null;
        }
    }
    
    /**
     * Altera um cozinheiro
     * @param componentes
     * @param cozinheiro 
     */
    public void alterarCozinheiro(List componentes, Cozinheiro cozinheiro)
    {
        try {
            System.out.println("CtrlInterno -  alterarCozinheiro(List componentes, Cozinheiro cozinheiro)");
            aplControleInterno.alterarCozinheiro(componentes, cozinheiro);
        } 
        catch (Exception ex) {
            System.err.println("Erro em alterar o cozinheiro!");
        }
    }

    /**
     * Obtem todos os cozinheiros cadastrados
     * @return Uma lista com os cozinheiros
     */
    public List<Cozinheiro> obterCozinheiros() {
        try {
            System.out.println("CtrlInterno - obterCozinheiros()");
            return aplControleInterno.obterCozinheiros();
        } catch (Exception ex) {
            System.err.println(ex.getMessage());
            System.err.println("Erro em obter os cozinheiros");
            return null;

        }
    }
    
    /**
     * Exclui um cozinheiro
     * @param cozinheiro 
     */
    public void excluirCozinheiro(Cozinheiro cozinheiro)
    {
        try {
            System.out.println("CtrlInterno - excluirCozinheiro(Cozinheiro cozinheiro)");
            aplControleInterno.apagarCozinheiro(cozinheiro);
        } 
        catch (Exception ex) {
            System.err.println("Erro em excluir o cozinheiro!");
        }
    }
    
    /**
     * Inclui um caixa
     * @param componentes
     * @return O caixa cadastrado
     */
    public Caixa incluirCaixa(List componentes)
    {
        try {
            System.out.println("CtrlInterno -incluirCaixa(List componentes)");
            return aplControleInterno.incluirCaixa(componentes);
        } 
        catch (Exception ex) {
            System.out.println("Erro em incluir o caixa!");
            return null;
        }
    }
    
    /**
     * Altera um caixa
     * @param componentes
     * @param caixa 
     */
    public void alterarCaixa(List componentes, Caixa caixa)
    {
        try {
            System.out.println("CtrlInterno - alterarCaixa(List componentes, Caixa caixa)");
            aplControleInterno.alterarFuncionario(componentes, caixa);
        } 
        catch (Exception ex) {
            System.err.println("Erro em alterar o caixa!");
        }
    }

    /**
     * Obtem todos os caixas cadastrados
     * @return Uma lista com os caixas
     */
    public List<Caixa> obterCaixas() {
        try {
            System.out.println("CtrlInterno -  obterCaixas() ");
            return aplControleInterno.obterCaixas();
        } catch (Exception ex) {
            System.err.println(ex.getMessage());
            System.err.println("Erro em obter os caixas");
            return null;

        }
    }
    
    /**
     * Exclui um caixa
     * @param caixa 
     */
    public void excluirCaixa(Caixa caixa)
    {
        try {
            System.out.println("CtrlInterno -  excluirCaixa(Caixa caixa) ");
            aplControleInterno.apagarCaixa(caixa);
        } 
        catch (Exception ex) {
            System.err.println("Erro em excluir o caixa!");
        }
    }
    
    /**
     * Inclui um novo funcionario(caixa, cozinheiro, garçom, motoboy, telefonista)
     * @param componentes
     * @return O funcionario cadastrado
     */
    public Funcionario incluirFuncionario(List componentes)
    {
        try {
            System.out.println("CtrlInterno -  incluirFuncionario(List componentes) ");
            return aplControleInterno.incluirFuncionario(componentes);
        } 
        catch (Exception ex) {
            System.err.println(ex);
            return null;
        }
    }
    
    /**
     * Altera um funcionario(caixa, cozinheiro, garçom, motoboy, telefonista)
     * @param componentes
     * @param funcionario 
     */
    public void alterarFuncionario(List componentes, Funcionario funcionario)
    {
        try {
            System.out.println("CtrlInterno - alterarFuncionario(List componentes, Funcionario funcionario) ");
            aplControleInterno.alterarFuncionario(componentes, funcionario);
        } 
        catch (Exception ex) {
            System.err.println("Erro em alterar o funcionario!");
        }
    }

    /**
     * Obtem todos os funcionarios(caixa, cozinheiro, garçom, motoboy, telefonista) cadastrados
     * @return Uma lista com os funcionarios
     */
    public List<Funcionario> obterFuncionarios() {
        try {
            System.out.println("CtrlInterno -  obterFuncionarios() ");
            return aplControleInterno.obterFuncionarios();
        } catch (Exception ex) {
            System.err.println(ex.getMessage());
            System.err.println("Erro em obter os funcionarios");
            return null;

        }
    }
    
    /**
     * Exclui um funcionario(caixa, cozinheiro, garçom, motoboy, telefonista)
     * @param funcionario 
     */
    public void excluirFuncionario(Funcionario funcionario)
    {
        try {
            System.out.println("CtrlInterno - excluirFuncionario(Funcionario funcionario) ");
            aplControleInterno.apagarFuncionario(funcionario);
        } 
        catch (Exception ex) {
            System.err.println("Erro em excluir o funcionario!");
        }
    }
    
    /**
     * Exclui um funcionario da lista presente na janela eventos do funcionario
     * @param selectedRow 
     */
    public void acaoExcluirFuncionario(int selectedRow) {
        System.out.println("CtrlInterno -  acaoExcluirFuncionario(int selectedRow) ");
        excluirFuncionario(janFormularioFuncionario.getListFuncionario().get(selectedRow)); 
        janFormularioFuncionario.getListFuncionario().remove(selectedRow);
    }

    /**
     * Inclui um funcionario da lista presente na janela eventos do funcionario
     */
    public void abrirIncluirFormularioFuncionario() {
        System.out.println("CtrlInterno -  abrirIncluirFormularioFuncionario() ");
        janFormularioFuncionario.setMODO(tipo.INCLUIR);
        janFormularioFuncionario.acaoIncluir();
        janFormularioFuncionario.setVisible(true);
    }
    
    /**
     * Altera um funcionario da lista presente na janela eventos do funcionario
     * @param linhaSelecionada 
     */
    public void abrirAlterarFormularioFuncionario(int linhaSelecionada) {
        System.out.println("CtrlInterno -  abrirAlterarFormularioFuncionario(int linhaSelecionada) ");
        janFormularioFuncionario.setMODO(tipo.ALTERAR);
        janFormularioFuncionario.acaoAlterar(linhaSelecionada);
        janFormularioFuncionario.setVisible(true);
    }
    
    /**
     * Consulta um funcionario da lista presente na janela eventos do funcionario
     * @param linhaSelecionada 
     */
    public void abrirConsultarFormularioFuncionario(int linhaSelecionada) {
        System.out.println("CtrlInterno - abrirConsultarFormularioFuncionario(int linhaSelecionada)  ");
        janFormularioFuncionario.acaoConsultar(linhaSelecionada);
        janFormularioFuncionario.setVisible(true); 
    }
    
    /**
     * Atualiza a lista de funcionarios presente na janela de eventos do funcionario
     * @param t
     * @param qtd 
     */
    public void dadosFuncionario(TableModel t, int qtd) {
        for (int i = 0; i < qtd; i++) {
            ((DefaultTableModel) t).removeRow(0);
        }

        try {
            System.out.println("CtrlInterno - dadosFuncionario(TableModel t, int qtd)");
            janFormularioFuncionario.setListFuncionario(obterFuncionarios());
        } catch (Exception ex) {
            System.err.println(ex.getMessage());
            System.err.println("Erro em obter funcionarios");
        }
        if (janFormularioFuncionario.getListFuncionario() != null) {
            for (Funcionario obj : janFormularioFuncionario.getListFuncionario()) {
                switch(obj.getTipoFuncionario())
                {
                    case CAIXA:
                    {
                        Caixa c = (Caixa) obj;
                        ((DefaultTableModel) t).addRow(new Object[]{c.getNome(), c.getCpf().toString(),"NENHUMA","NÃO POSSUI", c.getTipoFuncionario()});
                        break;
                    }
                    case COZINHEIRO:
                    {
                        Cozinheiro c = (Cozinheiro) obj;
                        ((DefaultTableModel) t).addRow(new Object[]{c.getNome(), c.getCpf().toString(),c.getSituacao().toString(),c.getNumElaboracao().toString(), c.getTipoFuncionario()});
                        break;
                    }
                    case GARÇOM:
                    {
                        Garcom g = (Garcom) obj;
                        ((DefaultTableModel) t).addRow(new Object[]{g.getNome(), g.getCpf().toString(),"NENHUMA",g.getNumPedidos().toString(), g.getTipoFuncionario()});
                        break;
                    }
                    case MOTOBOY:
                    {
                        Motoboy m = (Motoboy) obj;
                        ((DefaultTableModel) t).addRow(new Object[]{m.getNome(), m.getCpf().toString(),m.getSituacao().toString(),m.getNumEntrega().toString(), m.getTipoFuncionario()});
                        break;
                    }
                    case TELEFONISTA:
                    {
                        Telefonista tel = (Telefonista) obj;
                        ((DefaultTableModel) t).addRow(new Object[]{tel.getNome(), tel.getCpf().toString(),"NENHUMA",tel.getNumPedido().toString(), tel.getTipoFuncionario()});
                        break;
                    }
                }
            }
        }
    }
    
    
    /**
     * Inclui um novo produto
     * @param componentes
     * @return 
     */
    public Produto incluirProduto(List componentes)
    {
        try {
            System.out.println("CtrlInterno -  incluirProduto(List componentes)");
            return aplControleInterno.incluirProduto(componentes);
        } 
        catch (Exception ex) {
            System.out.println("Erro em incluir o produto");
            return null;
        }
    }
    
    /**
     * Altera um produto
     * @param componentes
     * @param produto 
     */
    public void alterarProduto(List componentes, Produto produto)
    {
        try {
            System.out.println("CtrlInterno -  alterarProduto(List componentes, Produto produto)");
            aplControleInterno.alterarProduto(componentes, produto);
        } 
        catch (Exception ex) {
            System.err.println("Erro em alterar o produto!");
        }
    }

    /**
     * Obtem todos os produtos cadastrados
     * @return Uma lista com os produtos
     */
    public List<Produto> obterProdutos() {
        try {
            System.out.println("CtrlInterno -  obterProdutos()");
            return aplControleInterno.obterProdutos();
        } catch (Exception ex) {
            System.err.println(ex.getMessage());
            System.err.println("Erro em obter os produtos");
            return null;

        }
    }
    
    /**
     * Obtem todos os produtos cadastrados
     * @param tipo
     * @return Uma lista com os produtos
     */
    public List<Produto> obterProdutos(TipoProduto tipo)
    {
        System.out.println("CtrlInterno -  obterProdutos(TipoProduto tipo)");
        return aplControleInterno.obterProdutos(tipo);
    }
    
    /**
     * Exclui um produto
     * @param produto 
     */
    public void excluirProduto(Produto produto)
    {
        try {
            System.out.println("CtrlInterno -  excluirProduto(Produto produto)");
            aplControleInterno.apagarProduto(produto);
        } 
        catch (Exception ex) {
            System.err.println("Erro em excluir o produto!");
        }
    }
    
    /**
     * Exclui um produto na lista da janela de eventos do produto
     * @param selectedRow 
     */
    public void acaoExcluirProduto(int selectedRow) {
        System.out.println("CtrlInterno -  acaoExcluirProduto(int selectedRow)");
        excluirProduto(janFormularioProduto.getListProduto().get(selectedRow));
        janFormularioProduto.getListProduto().remove(selectedRow);
    }

    /**
     * Inclui um produto na lista da janela de eventos do produto
     */
    public void abrirIncluirFormularioProduto() {
        System.out.println("CtrlInterno - abrirIncluirFormularioProduto() ");
        janFormularioProduto.setMODO(tipo.INCLUIR);
        janFormularioProduto.acaoIncluir();
        janFormularioProduto.setVisible(true);
    }
    
    /**
     * Altera um produto na lista da janela de eventos do produto
     * @param linhaSelecionada 
     */
    public void abrirAlterarFormularioProduto(int linhaSelecionada) {
        System.out.println("CtrlInterno - abrirAlterarFormularioProduto(int linhaSelecionada) ");
        janFormularioProduto.setMODO(tipo.ALTERAR);
        janFormularioProduto.acaoAlterar(linhaSelecionada);
        janFormularioProduto.setVisible(true);
    }
    
    /**
     * Consulta um produto na lista da janela de eventos do produto
     * @param linhaSelecionada 
     */
    public void abrirConsultarFormularioProduto(int linhaSelecionada) {
        System.out.println("CtrlInterno - abrirConsultarFormularioProduto(int linhaSelecionada) ");
        janFormularioProduto.acaoConsultar(linhaSelecionada);
        janFormularioProduto.setVisible(true); 
    }
    
    /**
     * Atualiza a lista de produtos presente na janela de eventos do produto
     * @param t
     * @param qtd 
     */
    public void dadosProduto(TableModel t, int qtd) {
        for (int i = 0; i < qtd; i++) {
            ((DefaultTableModel) t).removeRow(0);
        }

        try {
            System.out.println("CtrlInterno -  dadosProduto(TableModel t, int qtd)  ");
            janFormularioProduto.setListProduto(obterProdutos());
        } catch (Exception ex) {
            System.err.println(ex.getMessage());
            System.err.println("Erro em obter produtos");
        }
        if (janFormularioProduto.getListProduto() != null) {
            for (Produto p : janFormularioProduto.getListProduto()) {
                ((DefaultTableModel) t).addRow(new Object[]{p.getNome(), p.getTipo().toString(),p.getValor().toString()});
            }
        }
    }
    
    /**
     * Atualiza a lista de produtos presente na janela de relarotio do produto
     * @param t
     * @param qtd 
     */
    public void dadosRelatorioProduto(TableModel t, int qtd,String tipoProduto, String minimo, String maximo) {
        System.out.println("CtrlInterno - dadosRelatorioProduto(TableModel t, int qtd,String tipoProduto, String minimo, String maximo) ");
        for (int i = 0; i < qtd; i++) {
            ((DefaultTableModel) t).removeRow(0);
        }
        List<Produto> produtos = null;
        switch(tipoProduto)
        {
            case "TODOS":
            {
                produtos = obterProdutos();
                break;
            }
            case "BEBIDA":
            {
                produtos = obterProdutos(TipoProduto.BEBIDA);
                break;
            }
            case "PRATO":
            {
                produtos = obterProdutos(TipoProduto.PRATO);
                break;
            }
            case "LANCHE":
            {
                produtos = obterProdutos(TipoProduto.LANCHE);
                break;
            }
            case "SOBREMESSA":
            {
                produtos = obterProdutos(TipoProduto.SOBREMESSA);
                break;
            }
        }
        ordenaList(produtos);
        if(minimo.equals("") && maximo.equals(""))
        {
            for (Produto p : produtos) {
                ((DefaultTableModel) t).addRow(new Object[]{p.getNome(), p.getTipo().toString(),p.getValor().toString()});
            }
        }
        else if(minimo.equals(""))
        {
            Double max = Double.parseDouble(maximo);
            for (Produto p : produtos) {
                if(p.getValor()<=max)
                {
                    ((DefaultTableModel) t).addRow(new Object[]{p.getNome(), p.getTipo().toString(),p.getValor().toString()});
                }
            }
        }
        else if (maximo.equals(""))
        {
            Double min = Double.parseDouble(minimo);
            for (Produto p : produtos) {
                if(p.getValor()>=min)
                {
                    ((DefaultTableModel) t).addRow(new Object[]{p.getNome(), p.getTipo().toString(),p.getValor().toString()});
                }
            }
        }
        else
        {
            Double max = Double.parseDouble(maximo);
            Double min = Double.parseDouble(minimo);
            for (Produto p : produtos) {
                if(p.getValor()>=min && p.getValor()<=max)
                {
                    ((DefaultTableModel) t).addRow(new Object[]{p.getNome(), p.getTipo().toString(),p.getValor().toString()});
                }
            }
        }    
        janRelatorioProduto.setProdutos(produtos);
        
        
    }
    
    /**
     * Consulta um produto na lista da janela de relatorio do produto
     * @param p 
     */
    public void abrirConsultarRelatorioProduto(Produto p) {
        System.out.println("CtrlInterno - abrirConsultarRelatorioProduto(Produto p) ");
        janFormularioProduto.montarTela(p);
        janFormularioProduto.arrumarTela(false);
        janFormularioProduto.jButton1.setVisible(false);
        janFormularioProduto.setVisible(true);
    }

    /**
     * Consulta um funcioanrio na lista da janela de relatorio do funcioanrio
     * @param f 
     */
    public void abrirConsultarRelatorioFuncionario(Funcionario f) {
        System.out.println("CtrlInterno - abrirConsultarRelatorioFuncionario(Funcionario f) ");
        janFormularioFuncionario.montarTela(f);
        janFormularioFuncionario.arrumarTela(false);
        janFormularioFuncionario.jButton1.setVisible(false);
        janFormularioFuncionario.setVisible(true);
    }
    
    /**
     * Atualiza a lista de funcionarios presente na janela de relarotio do funcionario
     * @param t
     * @param qtd
     * @param tipo 
     */
    public void dadosRelatorioFuncionario(TableModel t, int qtd, String tipo) {
        System.out.println("CtrlInterno - dadosRelatorioFuncionario(TableModel t, int qtd, String tipo) ");
        List<Caixa> caixas = null;
        List<Cozinheiro> cozinheiros = null;
        List<Garcom> garcons = null;
        List<Motoboy> motoboys = null;
        List<Telefonista> telefonistas = null;
        List<Funcionario> funcionarios = null;
        for (int i = 0; i < qtd; i++) {
            ((DefaultTableModel) t).removeRow(0);
        }
        switch (tipo) {
            case "TODOS":
            {
                try {
                    funcionarios = obterFuncionarios();
                } 
                catch (Exception ex) {
                    System.err.println(ex.getMessage());
                }
                if(funcionarios!=null)
                {
                    for (Funcionario obj : funcionarios) {
                         switch(obj.getTipoFuncionario())
                         {
                             case CAIXA:
                             {
                                 Caixa c = (Caixa) obj;
                                 ((DefaultTableModel) t).addRow(new Object[]{c.getNome(), c.getCpf().toString(),"NENHUMA","NÃO POSSUI", c.getTipoFuncionario()});
                                 break;
                             }
                             case COZINHEIRO:
                             {
                                 Cozinheiro c = (Cozinheiro) obj;
                                 ((DefaultTableModel) t).addRow(new Object[]{c.getNome(), c.getCpf().toString(),c.getSituacao().toString(),c.getNumElaboracao().toString(), c.getTipoFuncionario()});
                                 break;
                             }
                             case GARÇOM:
                             {
                                 Garcom g = (Garcom) obj;
                                 ((DefaultTableModel) t).addRow(new Object[]{g.getNome(), g.getCpf().toString(),"NENHUMA",g.getNumPedidos().toString(), g.getTipoFuncionario()});
                                 break;
                             }
                             case MOTOBOY:
                             {
                                 Motoboy m = (Motoboy) obj;
                                 ((DefaultTableModel) t).addRow(new Object[]{m.getNome(), m.getCpf().toString(),m.getSituacao().toString(),m.getNumEntrega().toString(), m.getTipoFuncionario()});
                                 break;
                             }
                             case TELEFONISTA:
                             {
                                 Telefonista tel = (Telefonista) obj;
                                 ((DefaultTableModel) t).addRow(new Object[]{tel.getNome(), tel.getCpf().toString(),"NENHUMA",tel.getNumPedido().toString(), tel.getTipoFuncionario()});
                                 break;
                             }
                         }
                        
                        
                    }
                }
                janRelatorioFuncionario.setFuncionarios(funcionarios);
                break;
            }
                
            case "CAIXA":
            {
                try {
                    caixas = obterCaixas();
                } 
                catch (Exception ex) {
                    System.err.println(ex.getMessage());
                }
                if(caixas!=null)
                {
                    for (Caixa obj : caixas) {
                        ((DefaultTableModel) t).addRow(new Object[]{obj.getNome(), obj.getCpf().toString(),"NENHUMA","NÃO POSSUI", obj.getTipoFuncionario()});
                    }
                }
                funcionarios = new ArrayList<>();
                funcionarios.addAll(caixas);
                janRelatorioFuncionario.setFuncionarios(funcionarios);
                break;
            }
            case "COZINHEIRO":
            {
                try {
                    cozinheiros = obterCozinheiros();
                } 
                catch (Exception ex) {
                    System.err.println(ex.getMessage());
                }
                if(cozinheiros!=null)
                {
                    for (Cozinheiro obj : cozinheiros) {
                        ((DefaultTableModel) t).addRow(new Object[]{obj.getNome(), obj.getCpf().toString(),obj.getSituacao().toString(),obj.getNumElaboracao().toString(), obj.getTipoFuncionario()});
                    }
                }
                funcionarios = new ArrayList<>();
                funcionarios.addAll(cozinheiros);
                janRelatorioFuncionario.setFuncionarios(funcionarios);
                break;
            }
            case "GARCOM":
            {
                try {
                    garcons = obterGarcons();
                } 
                catch (Exception ex) {
                    System.err.println(ex.getMessage());
                }
                if(garcons!=null)
                {
                    for (Garcom obj : garcons) {
                        ((DefaultTableModel) t).addRow(new Object[]{obj.getNome(), obj.getCpf().toString(),"NENHUMA",obj.getNumPedidos().toString(), obj.getTipoFuncionario()});
                    }
                }
                funcionarios = new ArrayList<>();
                funcionarios.addAll(garcons);
                janRelatorioFuncionario.setFuncionarios(funcionarios);
                break;
            }
            case "MOTOBOY":
            {
                try {
                    motoboys = obterMotoboys();
                } 
                catch (Exception ex) {
                    System.err.println(ex.getMessage());
                }
                if(motoboys!=null)
                {
                    for (Motoboy obj : motoboys) {
                        ((DefaultTableModel) t).addRow(new Object[]{obj.getNome(), obj.getCpf().toString(),obj.getSituacao().toString(),obj.getNumEntrega().toString(), obj.getTipoFuncionario()});
                    }
                }
                funcionarios = new ArrayList<>();
                funcionarios.addAll(motoboys);
                janRelatorioFuncionario.setFuncionarios(funcionarios);
                break;
            }
            case "TELEFONISTA":
            {
                try {
                    telefonistas = obterTelefonistas();
                } 
                catch (Exception ex) {
                    System.err.println(ex.getMessage());
                }
                if(telefonistas!=null)
                {
                    for (Telefonista obj : telefonistas) {
                        ((DefaultTableModel) t).addRow(new Object[]{obj.getNome(), obj.getCpf().toString(),"NENHUMA",obj.getNumPedido().toString(), obj.getTipoFuncionario()});
                    }
                }
                funcionarios = new ArrayList<>();
                funcionarios.addAll(telefonistas);
                janRelatorioFuncionario.setFuncionarios(funcionarios);
                break;
            }
        }
    }
    
    /**
     * Ordena uma lista de Produtos, por valor, em ordem crescente
     * @param produtos
     * @return A lista ordenada
     */
    private void ordenaList(List<Produto> produtos)
    {
        System.out.println("CtrlInterno - ordenaList(List<Produto> produtos) ");
        Comparator c = new Comparator<Produto>(){
            @Override
            public int compare(Produto o1, Produto o2)
            {
                    return (int) (o1.getValor()-o2.getValor());
            }
        };

        Collections.sort(produtos, c);
    }
}
